[CrashReporter] Enable InProc CrashReporter for crashing GC threads - #131821

src/coreclr/vm/crashreportstackwalker.cpp:601

• ThreadStore::GetThreadList() requires the current thread to hold the ThreadStore lock (it asserts s_pThreadStore->m_Crst.GetEnterCount() > 0). With the new CrashReportSuspensionOwnership::Existing path (e.g., stable Server GC worker where another thread owns the lock), this loop can trip that assert in checked builds and violates the existing ThreadStore locking contract.

To make the 'Existing but not owned by this thread' scenario safe, either (a) avoid enumerating other threads unless the current thread holds the ThreadStore lock, or (b) introduce an explicit "enumerate thread list while another thread holds the lock / SysIsSuspended" helper that does not require lock ownership, and use that here.

    if (suspensionOwnership != CrashReportSuspensionOwnership::Unavailable)
    {
        Thread* pThread = nullptr;
        while ((pThread = ThreadStore::GetThreadList(pThread)) != nullptr)
        {

src/coreclr/vm/crashreportstackwalker.cpp:534

• The comment says we should avoid calling SuspendEE when a suspension is already in progress, but the code doesn't check SysIsSuspendInProgress(). As a result, the crash reporter can still call SuspendEE while another thread is mid-suspension, which risks blocking on the ThreadStore lock (exactly what the comment says to avoid).

    if (g_fFatalErrorOccurredOnGCThread
        || GCHeapUtilities::IsGCInProgress()
        || crashThreadOwnsSuspension)
    {
        return CrashReportSuspensionOwnership::Unavailable;
    }

src/coreclr/inc/gccrashreport.h:12

• This introduces a direct VM->GC call surface (SVR::IsGCThreadUsingStableSuspension) that bypasses the existing standalone-GC loading/probing mechanism (GC_VersionInfo/GC_Initialize via direct link vs GetProcAddress). In builds that load a standalone GC, this symbol may not exist / may not be resolvable the same way, and even if it does, calling it directly would not follow the selected GC module.

Consider plumbing this through the same mechanism as other GC entrypoints (an extern "C" exported function resolved during GC load and stored as a function pointer, or an existing GC interface contract) and make the header comment match the actual behavior/availability guarantees.

// Crash reporting entry points implemented by the linked-in GC. Standalone GCs
// conservatively return false because they do not execute this linked-in GC code.
namespace SVR
{
    bool IsGCThreadUsingStableSuspension();
}